"""
手动对战队列定时处理器
"""
import threading
import time
import logging
from django.utils import timezone
from .battle_queue_manager import get_manual_battle_queue_manager

logger = logging.getLogger(__name__)


class QueueProcessor:
    """队列处理器 - 定时处理队列中的对战"""
    
    def __init__(self, interval=5):
        """
        初始化队列处理器
        
        Args:
            interval: 处理间隔（秒）
        """
        self.interval = interval
        self.is_running = False
        self.thread = None
        self.manager = get_manual_battle_queue_manager()
    
    def start(self):
        """启动队列处理器"""
        if self.is_running:
            logger.warning("队列处理器已经在运行中")
            return
        
        self.is_running = True
        self.thread = threading.Thread(target=self._run, daemon=True)
        self.thread.start()
        logger.info(f"队列处理器已启动，处理间隔: {self.interval}秒")
    
    def stop(self):
        """停止队列处理器"""
        if not self.is_running:
            return
        
        self.is_running = False
        if self.thread and self.thread.is_alive():
            self.thread.join(timeout=10)
        logger.info("队列处理器已停止")
    
    def _run(self):
        """运行队列处理循环"""
        logger.info("队列处理器开始运行")
        
        while self.is_running:
            try:
                # 处理队列
                self._process_queue()
                
                # 等待下一次处理
                time.sleep(self.interval)
                
            except Exception as e:
                logger.error(f"队列处理器运行时发生错误: {e}")
                # 发生错误时等待一段时间再继续
                time.sleep(self.interval)
    
    def _process_queue(self):
        """处理队列中的对战"""
        try:
            # 获取队列状态
            status = self.manager.get_queue_status()
            
            # 如果有等待中的对战且运行中的对战数量未达到上限
            if status['queue_count'] > 0 and status['running_count'] < status['max_concurrent_battles']:
                # ManualBattleQueueManager已经有自己的处理循环，这里只需要触发一次处理
                self.manager._start_pending_battles()
                logger.debug(f"队列处理器触发了一次对战启动检查")
            
        except Exception as e:
            logger.error(f"处理队列时发生错误: {e}")


# 全局队列处理器实例
_queue_processor = None


def get_queue_processor():
    """获取队列处理器单例"""
    global _queue_processor
    if _queue_processor is None:
        _queue_processor = QueueProcessor()
    return _queue_processor


def start_queue_processor():
    """启动队列处理器"""
    processor = get_queue_processor()
    processor.start()


def stop_queue_processor():
    """停止队列处理器"""
    processor = get_queue_processor()
    processor.stop()